drivers/usb/gadget/function/storage_common.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * storage_common.c -- Common definitions for mass storage functionality
   4  *
   5  * Copyright (C) 2003-2008 Alan Stern
   6  * Copyeight (C) 2009 Samsung Electronics
   7  * Author: Michal Nazarewicz (mina86@mina86.com)
   8  */
   9
  10 /*
  11  * This file requires the following identifiers used in USB strings to
  12  * be defined (each of type pointer to char):
  13  *  - fsg_string_interface    -- name of the interface
  14  */
  15
  16 /*
  17  * When USB_GADGET_DEBUG_FILES is defined the module param num_buffers
  18  * sets the number of pipeline buffers (length of the fsg_buffhd array).
  19  * The valid range of num_buffers is: num >= 2 && num <= 4.
  20  */
  21
  22 #include <linux/module.h>
  23 #include <linux/blkdev.h>
  24 #include <linux/file.h>
  25 #include <linux/fs.h>
  26 #include <linux/usb/composite.h>
  27
  28 #include "storage_common.h"
  29
  30 /* There is only one interface. */
  31
  32 struct usb_interface_descriptor fsg_intf_desc = {
  33         .bLength =              sizeof fsg_intf_desc,
  34         .bDescriptorType =      USB_DT_INTERFACE,
  35
  36         .bNumEndpoints =        2,              /* Adjusted during fsg_bind() */
  37         .bInterfaceClass =      USB_CLASS_MASS_STORAGE,
  38         .bInterfaceSubClass =   USB_SC_SCSI,    /* Adjusted during fsg_bind() */
  39         .bInterfaceProtocol =   USB_PR_BULK,    /* Adjusted during fsg_bind() */
  40         .iInterface =           FSG_STRING_INTERFACE,
  41 };
  42 EXPORT_SYMBOL_GPL(fsg_intf_desc);
  43
  44 /*
  45  * Three full-speed endpoint descriptors: bulk-in, bulk-out, and
  46  * interrupt-in.
  47  */
  48
  49 struct usb_endpoint_descriptor fsg_fs_bulk_in_desc = {
  50         .bLength =              USB_DT_ENDPOINT_SIZE,
  51         .bDescriptorType =      USB_DT_ENDPOINT,
  52
  53         .bEndpointAddress =     USB_DIR_IN,
  54         .bmAttributes =         USB_ENDPOINT_XFER_BULK,
  55         /* wMaxPacketSize set by autoconfiguration */
  56 };
  57 EXPORT_SYMBOL_GPL(fsg_fs_bulk_in_desc);
  58
  59 struct usb_endpoint_descriptor fsg_fs_bulk_out_desc = {
  60         .bLength =              USB_DT_ENDPOINT_SIZE,
  61         .bDescriptorType =      USB_DT_ENDPOINT,
  62
  63         .bEndpointAddress =     USB_DIR_OUT,
  64         .bmAttributes =         USB_ENDPOINT_XFER_BULK,
  65         /* wMaxPacketSize set by autoconfiguration */
  66 };
  67 EXPORT_SYMBOL_GPL(fsg_fs_bulk_out_desc);
  68
  69 struct usb_descriptor_header *fsg_fs_function[] = {
  70         (struct usb_descriptor_header *) &fsg_intf_desc,
  71         (struct usb_descriptor_header *) &fsg_fs_bulk_in_desc,
  72         (struct usb_descriptor_header *) &fsg_fs_bulk_out_desc,
  73         NULL,
  74 };
  75 EXPORT_SYMBOL_GPL(fsg_fs_function);
  76
  77
  78 /*
  79  * USB 2.0 devices need to expose both high speed and full speed
  80  * descriptors, unless they only run at full speed.
  81  *
  82  * That means alternate endpoint descriptors (bigger packets).
  83  */
  84 struct usb_endpoint_descriptor fsg_hs_bulk_in_desc = {
  85         .bLength =              USB_DT_ENDPOINT_SIZE,
  86         .bDescriptorType =      USB_DT_ENDPOINT,
  87
  88         /* bEndpointAddress copied from fs_bulk_in_desc during fsg_bind() */
  89         .bmAttributes =         USB_ENDPOINT_XFER_BULK,
  90         .wMaxPacketSize =       cpu_to_le16(512),
  91 };
  92 EXPORT_SYMBOL_GPL(fsg_hs_bulk_in_desc);
  93
  94 struct usb_endpoint_descriptor fsg_hs_bulk_out_desc = {
  95         .bLength =              USB_DT_ENDPOINT_SIZE,
  96         .bDescriptorType =      USB_DT_ENDPOINT,
  97
  98         /* bEndpointAddress copied from fs_bulk_out_desc during fsg_bind() */
  99         .bmAttributes =         USB_ENDPOINT_XFER_BULK,
 100         .wMaxPacketSize =       cpu_to_le16(512),
 101         .bInterval =            1,      /* NAK every 1 uframe */
 102 };
 103 EXPORT_SYMBOL_GPL(fsg_hs_bulk_out_desc);
 104
 105
 106 struct usb_descriptor_header *fsg_hs_function[] = {
 107         (struct usb_descriptor_header *) &fsg_intf_desc,
 108         (struct usb_descriptor_header *) &fsg_hs_bulk_in_desc,
 109         (struct usb_descriptor_header *) &fsg_hs_bulk_out_desc,
 110         NULL,
 111 };
 112 EXPORT_SYMBOL_GPL(fsg_hs_function);
 113
 114 struct usb_endpoint_descriptor fsg_ss_bulk_in_desc = {
 115         .bLength =              USB_DT_ENDPOINT_SIZE,
 116         .bDescriptorType =      USB_DT_ENDPOINT,
 117
 118         /* bEndpointAddress copied from fs_bulk_in_desc during fsg_bind() */
 119         .bmAttributes =         USB_ENDPOINT_XFER_BULK,
 120         .wMaxPacketSize =       cpu_to_le16(1024),
 121 };
 122 EXPORT_SYMBOL_GPL(fsg_ss_bulk_in_desc);
 123
 124 struct usb_ss_ep_comp_descriptor fsg_ss_bulk_in_comp_desc = {
 125         .bLength =              sizeof(fsg_ss_bulk_in_comp_desc),
 126         .bDescriptorType =      USB_DT_SS_ENDPOINT_COMP,
 127
 128         /*.bMaxBurst =          DYNAMIC, */
 129 };
 130 EXPORT_SYMBOL_GPL(fsg_ss_bulk_in_comp_desc);
 131
 132 struct usb_endpoint_descriptor fsg_ss_bulk_out_desc = {
 133         .bLength =              USB_DT_ENDPOINT_SIZE,
 134         .bDescriptorType =      USB_DT_ENDPOINT,
 135
 136         /* bEndpointAddress copied from fs_bulk_out_desc during fsg_bind() */
 137         .bmAttributes =         USB_ENDPOINT_XFER_BULK,
 138         .wMaxPacketSize =       cpu_to_le16(1024),
 139 };
 140 EXPORT_SYMBOL_GPL(fsg_ss_bulk_out_desc);
 141
 142 struct usb_ss_ep_comp_descriptor fsg_ss_bulk_out_comp_desc = {
 143         .bLength =              sizeof(fsg_ss_bulk_in_comp_desc),
 144         .bDescriptorType =      USB_DT_SS_ENDPOINT_COMP,
 145
 146         /*.bMaxBurst =          DYNAMIC, */
 147 };
 148 EXPORT_SYMBOL_GPL(fsg_ss_bulk_out_comp_desc);
 149
 150 struct usb_descriptor_header *fsg_ss_function[] = {
 151         (struct usb_descriptor_header *) &fsg_intf_desc,
 152         (struct usb_descriptor_header *) &fsg_ss_bulk_in_desc,
 153         (struct usb_descriptor_header *) &fsg_ss_bulk_in_comp_desc,
 154         (struct usb_descriptor_header *) &fsg_ss_bulk_out_desc,
 155         (struct usb_descriptor_header *) &fsg_ss_bulk_out_comp_desc,
 156         NULL,
 157 };
 158 EXPORT_SYMBOL_GPL(fsg_ss_function);
 159
 160
 161  /*-------------------------------------------------------------------------*/
 162
 163 /*
 164  * If the next two routines are called while the gadget is registered,
 165  * the caller must own fsg->filesem for writing.
 166  */
 167
 168 void fsg_lun_close(struct fsg_lun *curlun)
 169 {
 170         if (curlun->filp) {
 171                 LDBG(curlun, "close backing file\n");
 172                 fput(curlun->filp);
 173                 curlun->filp = NULL;
 174         }
 175 }
 176 EXPORT_SYMBOL_GPL(fsg_lun_close);
 177
 178 int fsg_lun_open(struct fsg_lun *curlun, const char *filename)
 179 {
 180         int                             ro;
 181         struct file                     *filp = NULL;
 182         int                             rc = -EINVAL;
 183         struct inode                    *inode = NULL;
 184         loff_t                          size;
 185         loff_t                          num_sectors;
 186         loff_t                          min_sectors;
 187         unsigned int                    blkbits;
 188         unsigned int                    blksize;
 189
 190         /* R/W if we can, R/O if we must */
 191         ro = curlun->initially_ro;
 192         if (!ro) {
 193                 filp = filp_open(filename, O_RDWR | O_LARGEFILE, 0);
 194                 if (PTR_ERR(filp) == -EROFS || PTR_ERR(filp) == -EACCES)
 195                         ro = 1;
 196         }
 197         if (ro)
 198                 filp = filp_open(filename, O_RDONLY | O_LARGEFILE, 0);
 199         if (IS_ERR(filp)) {
 200                 LINFO(curlun, "unable to open backing file: %s\n", filename);
 201                 return PTR_ERR(filp);
 202         }
 203
 204         if (!(filp->f_mode & FMODE_WRITE))
 205                 ro = 1;
 206
 207         inode = file_inode(filp);
 208         if ((!S_ISREG(inode->i_mode) && !S_ISBLK(inode->i_mode))) {
 209                 LINFO(curlun, "invalid file type: %s\n", filename);
 210                 goto out;
 211         }
 212
 213         /*
 214          * If we can't read the file, it's no good.
 215          * If we can't write the file, use it read-only.
 216          */
 217         if (!(filp->f_mode & FMODE_CAN_READ)) {
 218                 LINFO(curlun, "file not readable: %s\n", filename);
 219                 goto out;
 220         }
 221         if (!(filp->f_mode & FMODE_CAN_WRITE))
 222                 ro = 1;
 223
 224         size = i_size_read(inode->i_mapping->host);
 225         if (size < 0) {
 226                 LINFO(curlun, "unable to find file size: %s\n", filename);
 227                 rc = (int) size;
 228                 goto out;
 229         }
 230
 231         if (curlun->cdrom) {
 232                 blksize = 2048;
 233                 blkbits = 11;
 234         } else if (inode->i_bdev) {
 235                 blksize = bdev_logical_block_size(inode->i_bdev);
 236                 blkbits = blksize_bits(blksize);
 237         } else {
 238                 blksize = 512;
 239                 blkbits = 9;
 240         }
 241
 242         num_sectors = size >> blkbits; /* File size in logic-block-size blocks */
 243         min_sectors = 1;
 244         if (curlun->cdrom) {
 245                 min_sectors = 300;      /* Smallest track is 300 frames */
 246                 if (num_sectors >= 256*60*75) {
 247                         num_sectors = 256*60*75 - 1;
 248                         LINFO(curlun, "file too big: %s\n", filename);
 249                         LINFO(curlun, "using only first %d blocks\n",
 250                                         (int) num_sectors);
 251                 }
 252         }
 253         if (num_sectors < min_sectors) {
 254                 LINFO(curlun, "file too small: %s\n", filename);
 255                 rc = -ETOOSMALL;
 256                 goto out;
 257         }
 258
 259         if (fsg_lun_is_open(curlun))
 260                 fsg_lun_close(curlun);
 261
 262         curlun->blksize = blksize;
 263         curlun->blkbits = blkbits;
 264         curlun->ro = ro;
 265         curlun->filp = filp;
 266         curlun->file_length = size;
 267         curlun->num_sectors = num_sectors;
 268         LDBG(curlun, "open backing file: %s\n", filename);
 269         return 0;
 270
 271 out:
 272         fput(filp);
 273         return rc;
 274 }
 275 EXPORT_SYMBOL_GPL(fsg_lun_open);
 276
 277
 278 /*-------------------------------------------------------------------------*/
 279
 280 /*
 281  * Sync the file data, don't bother with the metadata.
 282  * This code was copied from fs/buffer.c:sys_fdatasync().
 283  */
 284 int fsg_lun_fsync_sub(struct fsg_lun *curlun)
 285 {
 286         struct file     *filp = curlun->filp;
 287
 288         if (curlun->ro || !filp)
 289                 return 0;
 290         return vfs_fsync(filp, 1);
 291 }
 292 EXPORT_SYMBOL_GPL(fsg_lun_fsync_sub);
 293
 294 void store_cdrom_address(u8 *dest, int msf, u32 addr)
 295 {
 296         if (msf) {
 297                 /* Convert to Minutes-Seconds-Frames */
 298                 addr >>= 2;             /* Convert to 2048-byte frames */
 299                 addr += 2*75;           /* Lead-in occupies 2 seconds */
 300                 dest[3] = addr % 75;    /* Frames */
 301                 addr /= 75;
 302                 dest[2] = addr % 60;    /* Seconds */
 303                 addr /= 60;
 304                 dest[1] = addr;         /* Minutes */
 305                 dest[0] = 0;            /* Reserved */
 306         } else {
 307                 /* Absolute sector */
 308                 put_unaligned_be32(addr, dest);
 309         }
 310 }
 311 EXPORT_SYMBOL_GPL(store_cdrom_address);
 312
 313 /*-------------------------------------------------------------------------*/
 314
 315
 316 ssize_t fsg_show_ro(struct fsg_lun *curlun, char *buf)
 317 {
 318         return sprintf(buf, "%d\n", fsg_lun_is_open(curlun)
 319                                   ? curlun->ro
 320                                   : curlun->initially_ro);
 321 }
 322 EXPORT_SYMBOL_GPL(fsg_show_ro);
 323
 324 ssize_t fsg_show_nofua(struct fsg_lun *curlun, char *buf)
 325 {
 326         return sprintf(buf, "%u\n", curlun->nofua);
 327 }
 328 EXPORT_SYMBOL_GPL(fsg_show_nofua);
 329
 330 ssize_t fsg_show_file(struct fsg_lun *curlun, struct rw_semaphore *filesem,
 331                       char *buf)
 332 {
 333         char            *p;
 334         ssize_t         rc;
 335
 336         down_read(filesem);
 337         if (fsg_lun_is_open(curlun)) {  /* Get the complete pathname */
 338                 p = file_path(curlun->filp, buf, PAGE_SIZE - 1);
 339                 if (IS_ERR(p))
 340                         rc = PTR_ERR(p);
 341                 else {
 342                         rc = strlen(p);
 343                         memmove(buf, p, rc);
 344                         buf[rc] = '\n';         /* Add a newline */
 345                         buf[++rc] = 0;
 346                 }
 347         } else {                                /* No file, return 0 bytes */
 348                 *buf = 0;
 349                 rc = 0;
 350         }
 351         up_read(filesem);
 352         return rc;
 353 }
 354 EXPORT_SYMBOL_GPL(fsg_show_file);
 355
 356 ssize_t fsg_show_cdrom(struct fsg_lun *curlun, char *buf)
 357 {
 358         return sprintf(buf, "%u\n", curlun->cdrom);
 359 }
 360 EXPORT_SYMBOL_GPL(fsg_show_cdrom);
 361
 362 ssize_t fsg_show_removable(struct fsg_lun *curlun, char *buf)
 363 {
 364         return sprintf(buf, "%u\n", curlun->removable);
 365 }
 366 EXPORT_SYMBOL_GPL(fsg_show_removable);
 367
 368 ssize_t fsg_show_inquiry_string(struct fsg_lun *curlun, char *buf)
 369 {
 370         return sprintf(buf, "%s\n", curlun->inquiry_string);
 371 }
 372 EXPORT_SYMBOL_GPL(fsg_show_inquiry_string);
 373
 374 /*
 375  * The caller must hold fsg->filesem for reading when calling this function.
 376  */
 377 static ssize_t _fsg_store_ro(struct fsg_lun *curlun, bool ro)
 378 {
 379         if (fsg_lun_is_open(curlun)) {
 380                 LDBG(curlun, "read-only status change prevented\n");
 381                 return -EBUSY;
 382         }
 383
 384         curlun->ro = ro;
 385         curlun->initially_ro = ro;
 386         LDBG(curlun, "read-only status set to %d\n", curlun->ro);
 387
 388         return 0;
 389 }
 390
 391 ssize_t fsg_store_ro(struct fsg_lun *curlun, struct rw_semaphore *filesem,
 392                      const char *buf, size_t count)
 393 {
 394         ssize_t         rc;
 395         bool            ro;
 396
 397         rc = strtobool(buf, &ro);
 398         if (rc)
 399                 return rc;
 400
 401         /*
 402          * Allow the write-enable status to change only while the
 403          * backing file is closed.
 404          */
 405         down_read(filesem);
 406         rc = _fsg_store_ro(curlun, ro);
 407         if (!rc)
 408                 rc = count;
 409         up_read(filesem);
 410
 411         return rc;
 412 }
 413 EXPORT_SYMBOL_GPL(fsg_store_ro);
 414
 415 ssize_t fsg_store_nofua(struct fsg_lun *curlun, const char *buf, size_t count)
 416 {
 417         bool            nofua;
 418         int             ret;
 419
 420         ret = strtobool(buf, &nofua);
 421         if (ret)
 422                 return ret;
 423
 424         /* Sync data when switching from async mode to sync */
 425         if (!nofua && curlun->nofua)
 426                 fsg_lun_fsync_sub(curlun);
 427
 428         curlun->nofua = nofua;
 429
 430         return count;
 431 }
 432 EXPORT_SYMBOL_GPL(fsg_store_nofua);
 433
 434 ssize_t fsg_store_file(struct fsg_lun *curlun, struct rw_semaphore *filesem,
 435                        const char *buf, size_t count)
 436 {
 437         int             rc = 0;
 438
 439         if (curlun->prevent_medium_removal && fsg_lun_is_open(curlun)) {
 440                 LDBG(curlun, "eject attempt prevented\n");
 441                 return -EBUSY;                          /* "Door is locked" */
 442         }
 443
 444         /* Remove a trailing newline */
 445         if (count > 0 && buf[count-1] == '\n')
 446                 ((char *) buf)[count-1] = 0;            /* Ugh! */
 447
 448         /* Load new medium */
 449         down_write(filesem);
 450         if (count > 0 && buf[0]) {
 451                 /* fsg_lun_open() will close existing file if any. */
 452                 rc = fsg_lun_open(curlun, buf);
 453                 if (rc == 0)
 454                         curlun->unit_attention_data =
 455                                         SS_NOT_READY_TO_READY_TRANSITION;
 456         } else if (fsg_lun_is_open(curlun)) {
 457                 fsg_lun_close(curlun);
 458                 curlun->unit_attention_data = SS_MEDIUM_NOT_PRESENT;
 459         }
 460         up_write(filesem);
 461         return (rc < 0 ? rc : count);
 462 }
 463 EXPORT_SYMBOL_GPL(fsg_store_file);
 464
 465 ssize_t fsg_store_cdrom(struct fsg_lun *curlun, struct rw_semaphore *filesem,
 466                         const char *buf, size_t count)
 467 {
 468         bool            cdrom;
 469         int             ret;
 470
 471         ret = strtobool(buf, &cdrom);
 472         if (ret)
 473                 return ret;
 474
 475         down_read(filesem);
 476         ret = cdrom ? _fsg_store_ro(curlun, true) : 0;
 477
 478         if (!ret) {
 479                 curlun->cdrom = cdrom;
 480                 ret = count;
 481         }
 482         up_read(filesem);
 483
 484         return ret;
 485 }
 486 EXPORT_SYMBOL_GPL(fsg_store_cdrom);
 487
 488 ssize_t fsg_store_removable(struct fsg_lun *curlun, const char *buf,
 489                             size_t count)
 490 {
 491         bool            removable;
 492         int             ret;
 493
 494         ret = strtobool(buf, &removable);
 495         if (ret)
 496                 return ret;
 497
 498         curlun->removable = removable;
 499
 500         return count;
 501 }
 502 EXPORT_SYMBOL_GPL(fsg_store_removable);
 503
 504 ssize_t fsg_store_inquiry_string(struct fsg_lun *curlun, const char *buf,
 505                                  size_t count)
 506 {
 507         const size_t len = min(count, sizeof(curlun->inquiry_string));
 508
 509         if (len == 0 || buf[0] == '\n') {
 510                 curlun->inquiry_string[0] = 0;
 511         } else {
 512                 snprintf(curlun->inquiry_string,
 513                          sizeof(curlun->inquiry_string), "%-28s", buf);
 514                 if (curlun->inquiry_string[len-1] == '\n')
 515                         curlun->inquiry_string[len-1] = ' ';
 516         }
 517
 518         return count;
 519 }
 520 EXPORT_SYMBOL_GPL(fsg_store_inquiry_string);
 521
 522 MODULE_LICENSE("GPL");