fs/smbfs/file.c

   1 /*
   2  *  file.c
   3  *
   4  *  Copyright (C) 1995, 1996, 1997 by Paal-Kr. Engstad and Volker Lendecke
   5  *  Copyright (C) 1997 by Volker Lendecke
   6  *
   7  */
   8
   9 #include <linux/sched.h>
  10 #include <linux/kernel.h>
  11 #include <linux/errno.h>
  12 #include <linux/fcntl.h>
  13 #include <linux/stat.h>
  14 #include <linux/mm.h>
  15 #include <linux/malloc.h>
  16 #include <linux/pagemap.h>
  17
  18 #include <asm/uaccess.h>
  19 #include <asm/system.h>
  20
  21 #include <linux/smbno.h>
  22 #include <linux/smb_fs.h>
  23
  24 #define SMBFS_PARANOIA 1
  25 /* #define SMBFS_DEBUG_VERBOSE 1 */
  26 /* #define pr_debug printk */
  27
  28 static inline int
  29 min(int a, int b)
  30 {
  31         return a < b ? a : b;
  32 }
  33
  34 static inline void
  35 smb_unlock_page(struct page *page)
  36 {
  37         clear_bit(PG_locked, &page->flags);
  38         wake_up(&page->wait);
  39 }
  40
  41 static int
  42 smb_fsync(struct file *file, struct dentry * dentry)
  43 {
  44 #ifdef SMBFS_DEBUG_VERBOSE
  45 printk("smb_fsync: sync file %s/%s\n",
  46 dentry->d_parent->d_name.name, dentry->d_name.name);
  47 #endif
  48         return 0;
  49 }
  50
  51 /*
  52  * Read a page synchronously.
  53  */
  54 static int
  55 smb_readpage_sync(struct dentry *dentry, struct page *page)
  56 {
  57         char *buffer = (char *) page_address(page);
  58         unsigned long offset = page->offset;
  59         int rsize = smb_get_rsize(server_from_dentry(dentry));
  60         int count = PAGE_SIZE;
  61         int result;
  62
  63         clear_bit(PG_error, &page->flags);
  64
  65 #ifdef SMBFS_DEBUG_VERBOSE
  66 printk("smb_readpage_sync: file %s/%s, count=%d@%ld, rsize=%d\n",
  67 dentry->d_parent->d_name.name, dentry->d_name.name, count, offset, rsize);
  68 #endif
  69         result = smb_open(dentry, SMB_O_RDONLY);
  70         if (result < 0)
  71         {
  72 #ifdef SMBFS_PARANOIA
  73 printk("smb_readpage_sync: %s/%s open failed, error=%d\n",
  74 dentry->d_parent->d_name.name, dentry->d_name.name, result);
  75 #endif
  76                 goto io_error;
  77         }
  78
  79         do {
  80                 if (count < rsize)
  81                         rsize = count;
  82
  83                 result = smb_proc_read(dentry, offset, rsize, buffer);
  84                 if (result < 0)
  85                         goto io_error;
  86
  87                 count -= result;
  88                 offset += result;
  89                 buffer += result;
  90                 dentry->d_inode->i_atime = CURRENT_TIME;
  91                 if (result < rsize)
  92                         break;
  93         } while (count);
  94
  95         memset(buffer, 0, count);
  96         set_bit(PG_uptodate, &page->flags);
  97         result = 0;
  98
  99 io_error:
 100         smb_unlock_page(page);
 101         return result;
 102 }
 103
 104 int
 105 smb_readpage(struct file *file, struct page *page)
 106 {
 107         struct dentry *dentry = file->f_dentry;
 108         int             error;
 109
 110         pr_debug("SMB: smb_readpage %08lx\n", page_address(page));
 111 #ifdef SMBFS_PARANOIA
 112         if (test_bit(PG_locked, &page->flags))
 113                 printk("smb_readpage: page already locked!\n");
 114 #endif
 115         set_bit(PG_locked, &page->flags);
 116         atomic_inc(&page->count);
 117         error = smb_readpage_sync(dentry, page);
 118         free_page(page_address(page));
 119         return error;
 120 }
 121
 122 /*
 123  * Write a page synchronously.
 124  * Offset is the data offset within the page.
 125  */
 126 static int
 127 smb_writepage_sync(struct dentry *dentry, struct page *page,
 128                    unsigned long offset, unsigned int count)
 129 {
 130         struct inode *inode = dentry->d_inode;
 131         u8 *buffer = (u8 *) page_address(page) + offset;
 132         int wsize = smb_get_wsize(server_from_dentry(dentry));
 133         int result, written = 0;
 134
 135         offset += page->offset;
 136 #ifdef SMBFS_DEBUG_VERBOSE
 137 printk("smb_writepage_sync: file %s/%s, count=%d@%ld, wsize=%d\n",
 138 dentry->d_parent->d_name.name, dentry->d_name.name, count, offset, wsize);
 139 #endif
 140
 141         do {
 142                 if (count < wsize)
 143                         wsize = count;
 144
 145                 result = smb_proc_write(dentry, offset, wsize, buffer);
 146                 if (result < 0)
 147                         goto io_error;
 148                 /* N.B. what if result < wsize?? */
 149 #ifdef SMBFS_PARANOIA
 150 if (result < wsize)
 151 printk("smb_writepage_sync: short write, wsize=%d, result=%d\n", wsize, result);
 152 #endif
 153                 buffer += wsize;
 154                 offset += wsize;
 155                 written += wsize;
 156                 count -= wsize;
 157                 /*
 158                  * Update the inode now rather than waiting for a refresh.
 159                  */
 160                 inode->i_mtime = inode->i_atime = CURRENT_TIME;
 161                 if (offset > inode->i_size)
 162                         inode->i_size = offset;
 163                 inode->u.smbfs_i.cache_valid |= SMB_F_LOCALWRITE;
 164         } while (count);
 165
 166 out:
 167         smb_unlock_page(page);
 168         return written ? written : result;
 169
 170 io_error:
 171         /* Must mark the page invalid after I/O error */
 172         clear_bit(PG_uptodate, &page->flags);
 173         goto out;
 174 }
 175
 176 /*
 177  * Write a page to the server. This will be used for NFS swapping only
 178  * (for now), and we currently do this synchronously only.
 179  */
 180 static int
 181 smb_writepage(struct file *file, struct page *page)
 182 {
 183         struct dentry *dentry = file->f_dentry;
 184         int     result;
 185
 186 #ifdef SMBFS_PARANOIA
 187         if (test_bit(PG_locked, &page->flags))
 188                 printk("smb_writepage: page already locked!\n");
 189 #endif
 190         set_bit(PG_locked, &page->flags);
 191         atomic_inc(&page->count);
 192         result = smb_writepage_sync(dentry, page, 0, PAGE_SIZE);
 193         free_page(page_address(page));
 194         return result;
 195 }
 196
 197 static int
 198 smb_updatepage(struct file *file, struct page *page, const char *buffer,
 199                unsigned long offset, unsigned int count, int sync)
 200 {
 201         struct dentry *dentry = file->f_dentry;
 202         unsigned long page_addr = page_address(page);
 203         int result;
 204
 205         pr_debug("SMBFS: smb_updatepage(%s/%s %d@%ld, sync=%d)\n",
 206                 dentry->d_parent->d_name.name, dentry->d_name.name,
 207                 count, page->offset+offset, sync);
 208
 209 #ifdef SMBFS_PARANOIA
 210         if (test_bit(PG_locked, &page->flags))
 211                 printk("smb_updatepage: page already locked!\n");
 212 #endif
 213         set_bit(PG_locked, &page->flags);
 214         atomic_inc(&page->count);
 215
 216         if (copy_from_user((char *) page_addr + offset, buffer, count))
 217                 goto bad_fault;
 218         result = smb_writepage_sync(dentry, page, offset, count);
 219 out:
 220         free_page(page_addr);
 221         return result;
 222
 223 bad_fault:
 224 #ifdef SMBFS_PARANOIA
 225 printk("smb_updatepage: fault at addr=%lu, offset=%lu, buffer=%p\n",
 226 page_addr, offset, buffer);
 227 #endif
 228         result = -EFAULT;
 229         clear_bit(PG_uptodate, &page->flags);
 230         smb_unlock_page(page);
 231         goto out;
 232 }
 233
 234 static ssize_t
 235 smb_file_read(struct file * file, char * buf, size_t count, loff_t *ppos)
 236 {
 237         struct dentry * dentry = file->f_dentry;
 238         ssize_t status;
 239
 240 #ifdef SMBFS_DEBUG_VERBOSE
 241 printk("smb_file_read: file %s/%s, count=%lu@%lu\n",
 242 dentry->d_parent->d_name.name, dentry->d_name.name,
 243 (unsigned long) count, (unsigned long) *ppos);
 244 #endif
 245
 246         status = smb_revalidate_inode(dentry);
 247         if (status)
 248         {
 249 #ifdef SMBFS_PARANOIA
 250 printk("smb_file_read: %s/%s validation failed, error=%d\n",
 251 dentry->d_parent->d_name.name, dentry->d_name.name, status);
 252 #endif
 253                 goto out;
 254         }
 255
 256 #ifdef SMBFS_DEBUG_VERBOSE
 257 printk("smb_file_read: before read, size=%ld, pages=%ld, flags=%x, atime=%ld\n",
 258 dentry->d_inode->i_size, dentry->d_inode->i_nrpages, dentry->d_inode->i_flags,
 259 dentry->d_inode->i_atime);
 260 #endif
 261         status = generic_file_read(file, buf, count, ppos);
 262 out:
 263         return status;
 264 }
 265
 266 static int
 267 smb_file_mmap(struct file * file, struct vm_area_struct * vma)
 268 {
 269         struct dentry * dentry = file->f_dentry;
 270         int     status;
 271
 272 #ifdef SMBFS_DEBUG_VERBOSE
 273 printk("smb_file_mmap: file %s/%s, address %lu - %lu\n",
 274 dentry->d_parent->d_name.name, dentry->d_name.name, vma->vm_start, vma->vm_end);
 275 #endif
 276
 277         status = smb_revalidate_inode(dentry);
 278         if (status)
 279         {
 280 #ifdef SMBFS_PARANOIA
 281 printk("smb_file_mmap: %s/%s validation failed, error=%d\n",
 282 dentry->d_parent->d_name.name, dentry->d_name.name, status);
 283 #endif
 284                 goto out;
 285         }
 286         status = generic_file_mmap(file, vma);
 287 out:
 288         return status;
 289 }
 290
 291 /*
 292  * Write to a file (through the page cache).
 293  */
 294 static ssize_t
 295 smb_file_write(struct file *file, const char *buf, size_t count, loff_t *ppos)
 296 {
 297         struct dentry * dentry = file->f_dentry;
 298         ssize_t result;
 299
 300 #ifdef SMBFS_DEBUG_VERBOSE
 301 printk("smb_file_write: file %s/%s, count=%lu@%lu, pages=%ld\n",
 302 dentry->d_parent->d_name.name, dentry->d_name.name,
 303 (unsigned long) count, (unsigned long) *ppos, dentry->d_inode->i_nrpages);
 304 #endif
 305
 306         result = smb_revalidate_inode(dentry);
 307         if (result)
 308         {
 309 #ifdef SMBFS_PARANOIA
 310 printk("smb_file_write: %s/%s validation failed, error=%d\n",
 311 dentry->d_parent->d_name.name, dentry->d_name.name, result);
 312 #endif
 313                         goto out;
 314         }
 315
 316         result = smb_open(dentry, SMB_O_WRONLY);
 317         if (result)
 318                 goto out;
 319
 320         if (count > 0)
 321         {
 322                 result = generic_file_write(file, buf, count, ppos);
 323 #ifdef SMBFS_DEBUG_VERBOSE
 324 printk("smb_file_write: pos=%ld, size=%ld, mtime=%ld, atime=%ld\n",
 325 (long) file->f_pos, dentry->d_inode->i_size, dentry->d_inode->i_mtime,
 326 dentry->d_inode->i_atime);
 327 #endif
 328         }
 329 out:
 330         return result;
 331 }
 332
 333 static int
 334 smb_file_open(struct inode *inode, struct file * file)
 335 {
 336 #ifdef SMBFS_DEBUG_VERBOSE
 337 printk("smb_file_open: opening %s/%s, d_count=%d\n",
 338 file->f_dentry->d_parent->d_name.name, file->f_dentry->d_name.name,
 339 file->f_dentry->d_count);
 340 #endif
 341         return 0;
 342 }
 343
 344 static int
 345 smb_file_release(struct inode *inode, struct file * file)
 346 {
 347         struct dentry * dentry = file->f_dentry;
 348
 349 #ifdef SMBFS_DEBUG_VERBOSE
 350 printk("smb_file_release: closing %s/%s, d_count=%d\n",
 351 dentry->d_parent->d_name.name, dentry->d_name.name, dentry->d_count);
 352 #endif
 353
 354         if (dentry->d_count == 1)
 355         {
 356                 smb_close(inode);
 357         }
 358         return 0;
 359 }
 360
 361 /*
 362  * Check whether the required access is compatible with
 363  * an inode's permission. SMB doesn't recognize superuser
 364  * privileges, so we need our own check for this.
 365  */
 366 static int
 367 smb_file_permission(struct inode *inode, int mask)
 368 {
 369         int mode = inode->i_mode;
 370         int error = 0;
 371
 372 #ifdef SMBFS_DEBUG_VERBOSE
 373 printk("smb_file_permission: mode=%x, mask=%x\n", mode, mask);
 374 #endif
 375         /* Look at user permissions */
 376         mode >>= 6;
 377         if ((mode & 7 & mask) != mask)
 378                 error = -EACCES;
 379         return error;
 380 }
 381
 382 static struct file_operations smb_file_operations =
 383 {
 384         NULL,                   /* lseek - default */
 385         smb_file_read,          /* read */
 386         smb_file_write,         /* write */
 387         NULL,                   /* readdir - bad */
 388         NULL,                   /* poll - default */
 389         smb_ioctl,              /* ioctl */
 390         smb_file_mmap,          /* mmap(struct file*, struct vm_area_struct*) */
 391         smb_file_open,          /* open(struct inode*, struct file*) */
 392         NULL,                   /* flush */
 393         smb_file_release,       /* release(struct inode*, struct file*) */
 394         smb_fsync,              /* fsync(struct file*, struct dentry*) */
 395         NULL,                   /* fasync(struct file*, int) */
 396         NULL,                   /* check_media_change(kdev_t dev) */
 397         NULL,                   /* revalidate(kdev_t dev) */
 398         NULL                    /* lock(struct file*, int, struct file_lock*) */
 399 };
 400
 401 struct inode_operations smb_file_inode_operations =
 402 {
 403         &smb_file_operations,   /* default file operations */
 404         NULL,                   /* create */
 405         NULL,                   /* lookup */
 406         NULL,                   /* link */
 407         NULL,                   /* unlink */
 408         NULL,                   /* symlink */
 409         NULL,                   /* mkdir */
 410         NULL,                   /* rmdir */
 411         NULL,                   /* mknod */
 412         NULL,                   /* rename */
 413         NULL,                   /* readlink */
 414         NULL,                   /* follow_link */
 415         smb_readpage,           /* readpage */
 416         smb_writepage,          /* writepage */
 417         NULL,                   /* bmap */
 418         NULL,                   /* truncate */
 419         smb_file_permission,    /* permission */
 420         NULL,                   /* smap */
 421         smb_updatepage,         /* updatepage */
 422         smb_revalidate_inode,   /* revalidate */
 423 };